const fetch = require('../../utils/fetch')
const app = getApp()
Page({
    data: {
        payType: 1,//支付方式1->微信支付；4->余额支付
        code: '',//订单号，从待付款订单进入·的会在路由上携带订单号
        obj: "",//订单的商品信息或者购物车信息
        balance: 0,//余额
        promotionPrice: 0,//最终需要实际支付的金额
        // isBind: false,//用户是否绑定了手机号，未绑定时不予显示余额支付的选项
        template: '',//my_toast
        my_toast_tip: '',
        imageUrl:app.globalData.imageUrl
        
    },
    onLoad: function (options) {
        console.log('onLoad')
        // this.setData({
        //     isBind: app.globalData.userInfo.isBind
        // })
       
        //判断是否从未支付订单进入
        const code = options.code;
        if (code) {
            this.setData({
                code: code
            })
            this.getOrderByCode(code)
        } else {
            this.getOrderByCart()
        }
    },
    getOrderByCart:function(){
        fetch.loadingText({ title: '加载中',mask:true });
        fetch.getCart().then((response) => {
            fetch.hideLoadingText()
            const res = response.data
            if(res.code==200){
                if(!res.obj.haveGoods){
                    wx.showToast({
                        title: '空空如也~',
                        image: "../../image/warn.png",
                        duration: 1000,
                        complete:function(){
                            wx.redirectTo({
                                url: '../scan/scan'
                              })
                        }
                    })
                    return 
                }
                this.setData({
                    obj: res.obj,
                    promotionPrice: res.obj.promotionPrice
                })
                this.getBalance()

            }
        }).catch((err) => {
            fetch.hideLoadingText()
            console.log(err)
            fetch.showMyToast(this, err.data.des)
            
        })
    },
    getOrderByCode:function(code){
        fetch.loadingText({ title: '加载中',mask:true });
        fetch.getOrderByCode(code).then((response) => {
            fetch.hideLoadingText()
            const res = response.data;
            if (res.code == 200) {
                let newObj = this.reziseObj(res.obj);
                
                this.setData({
                    obj: newObj,
                    promotionPrice: newObj.promotionPrice
                })
                this.getBalance()
                // this.autoSelect();
            } 
        }).catch((err) => {
            fetch.hideLoadingText()
            fetch.showMyToast(this, err.data.des)
        })
    },
    getBalance:function(){
         // 获取余额
         fetch.getBalance().then((response) => {
            const res = response.data;
            this.setData({
                balance: res.obj.balance
            })
            this.autoSelect();
        }).catch((err) => {
            fetch.hideLoadingText()
            fetch.showMyToast(this, err.data.des)
        })
    },
    autoSelect: function () {
        const { promotionPrice, balance } = this.data;
        //未绑定手机号时，只容许微信支付；
        // console.log(promotionPrice, balance)
        // if (!isBind) {
        //     this.setData({
        //         payType: 1
        //     })
        //     return
        // }
        //订单支付金额为0时，只容许余额支付
        if (promotionPrice == 0) {
            // console.log('0')
            this.setData({
                payType: 4
            })
            return
        }

        // console.log(promotionPrice, balance,promotionPrice > balance)
        const payType =Number(promotionPrice)  > Number(balance)  ? 1 : 4;
        this.setData({
            payType: payType
        })

    },
    select_pay: function (event) {
        const type = event.currentTarget.dataset.type;
        console.log(type);
        const { promotionPrice, balance } = this.data;
        //未绑定手机号时，只容许微信支付；        
        // if (!isBind) {
        //     this.setData({
        //         payType: 1
        //     })
        //     return
        // }
        //订单支付金额为0时，只容许余额支付4
        if (promotionPrice == 0) {
            this.setData({
                payType: 4
            })
            wx.showToast({
                title: '请使用余额支付',
                image: '../../image/warn.png',
                duration: 1000
            })
            return
        }
        // 余额不足时,只能微信支付1
        if (Number(promotionPrice) > Number(balance)) {
            this.setData({
                payType: 1
            })
            wx.showToast({
                title: '余额不足',
                image: '../../image/warn.png',
                duration: 1000
            })
            return
        }
        this.setData({
            payType: type
        })

    },
    doPay: function () {
        fetch.loadingText({ title: '加载中',mask:true });({ title: '正在下单...', mask: true })
        //如果订单号已经存在，则是由待付款订单进入的，直接调用支付接口，否则要先创建订单
        const { payType, code } = this.data;
        console.log(payType, code);
        if (!code) {
            fetch.createOrder().then((response) => {
                fetch.hideLoadingText()
                const res = response.data;
                if (res.code == 200) {
                    this.setData({
                        code: res.obj
                    })
                    this.wxPay()

                } 

            }).catch((err) => {
                fetch.hideLoadingText()
                fetch.showMyToast(this,err.data.des)
            })
        } else {
            this.wxPay()
        }
    },
    wxPay: function () {
        var that=this;
        fetch.loadingText({ title: '加载中',mask:true });({ title: '支付中...', mask: true })
        fetch.getPayParams(this.data.code, this.data.payType).then((response) => {
            fetch.hideLoadingText();
            const res = response.data;
            // 支付方式为微信支付时
            if (res.code == 200 && this.data.payType == 1) {
                wx.requestPayment({
                    'timeStamp': res.obj.timeStamp,
                    'nonceStr': res.obj.nonceStr,
                    'package': res.obj.prepay_id,
                    'signType': res.obj.signType,
                    'paySign': res.obj.paySign,
                    'success': function (res) {
                        fetch.showToast({ title: '支付成功', icon: 'success', duration: 2000, mask: true })
                        //  wx.reLaunch在小程序进入后台后，无法运行，微信支付时，调用微信支付，所以不可用，而wx.switchTab无法携带参数（跳转mine.html需要刷新订单）       
                        app. globalData.common.selfPay=1                
                        wx.switchTab({
                            url:'../mine/mine'
                        })
                    },
                    'fail': function (res) {
                        console.log(res)
                        fetch.showMyToast(that,res.errMsg)
                        app. globalData.common.selfPay=1  
                        wx.switchTab({
                            url:'../mine/mine'
                        })
                    }
                })
            }
            // 支付方式为余额支付时
            else if (res.code == 200 && this.data.payType == 4) {
                fetch.showToast({ title: '成功', icon: 'success', duration: 2000, mask: true })
                    .then((response) => {
                        //  wx.reLaunch在小程序进入后台后，无法运行，余额支付时，不需要调用微信支付，所以可用
                        // wx.reLaunch({
                        //     url:'../mine/mine'
                        // })
                        app. globalData.common.selfPay=1                
                        wx.switchTab({
                            url:'../mine/mine'
                        })
                    }).catch((err) => {
                        fetch.showMyToast(that,err.data.des)
                        app. globalData.common.selfPay=1                
                        wx.switchTab({
                            url:'../mine/mine'
                        })
                    })
            }
            
        }).catch((err) => {
            fetch.hideLoadingText()
            fetch.showMyToast(this,err.data.des)


        })
    },
    reziseObj: function (obj) {
        let newObj = 
            {
                "originalPrice" : "",
                "promotionPrice" : "",
                "num" : 1,
                "cartItems" : []
                }
        newObj.originalPrice = obj.originalPrice;
        newObj.promotionPrice = obj.price;
        newObj.num = obj.num;
        obj.orderGoods.forEach(ele => {
            console.log("promotionType",ele.promotionType)
            newObj.cartItems.push(
                {
                    goods:{
                        imgUrl:ele.imagePath ,
                        goodsName:ele.goodsName,
                        originalPrice:ele.originalPrice,
                        price:ele.price,
                        promotionnName:ele.promotionnName,
                        promotionAlias:ele.promotionAlias
                    },
                    promotionType:ele.promotionType,
                    promotionName:ele.promotionName,
                    promotionAlias:ele.promotionAlias,
                    goodsName:ele.goodsName,
                    num:ele.num
                }
            )

        });
        return newObj
    },

    onReady: function () {
        // 生命周期函数--监听页面初次渲染完成

    },
    onReachBotton: function (e) {
        console.log(e)

    },
    onShow: function (e) {
        console.log('show')
        // 生命周期函数--监听页面显示


    },
    onHide: function () {
        // 生命周期函数--监听页面隐藏

    },
    onUnload: function () {
        // 生命周期函数--监听页面卸载

    },
    onPullDownRefresh: function () {
        // 页面相关事件处理函数--监听用户下拉动作

    },
    onReachBottom: function () {
        // 页面上拉触底事件的处理函数

    },
    onShareAppMessage: function () {
        // 用户点击右上角分享
        return {
            title: 'title', // 分享标题
            desc: 'desc', // 分享描述
            path: 'path' // 分享路径
        }
    }
})